package com.testword.service.impl;

import com.testword.entity.WordDifficulty;
import com.testword.mappers.DifficultyMapper;
import com.testword.service.DifficultyService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Slf4j
@Service
public class DifficultyServiceImpl   implements DifficultyService {
    @Autowired
    private DifficultyMapper difficultyMapper;

    private static final Pattern VOWEL_PATTERN = Pattern.compile("[aeiouy]", Pattern.CASE_INSENSITIVE);
    private static final Pattern CONSONANT_PATTERN = Pattern.compile("[bcdfghjklmnpqrstvwxz]", Pattern.CASE_INSENSITIVE);

    @Override
    public List<WordDifficulty> getAllDifficulties() {

        return difficultyMapper.getAllDifficulties();
    }

//    @Override
//    public List<Double> calculateDifficulty(List<String> words) {
//        List<Double> difficulties = new ArrayList<>();
//        for (String word : words) {
//            if (word == null || word.trim().isEmpty()) {
//                difficulties.add(0.0); // 空单词难度为0
//                continue;
//            }
//
//            // 1. 基础结构难度（最大5.0）
//            double baseDifficulty = calculateBaseDifficulty(word);
//
//            // 2. 拼写复杂度（最大4.0）
//            double spellingComplexity = calculateSpellingComplexity(word);
//
//            // 3. 词频权重（最大4.0，高频词权重低）
//            double frequencyWeight = calculateFrequencyWeight(word);
//
//            // 综合计算（基础+拼写-词频）
//            double difficulty = baseDifficulty + spellingComplexity - frequencyWeight;
//
//            // 确保结果在0-10范围内（冗余保护）
//            difficulty = Math.max(0.0, Math.min(10.0, difficulty));
//
//            difficulties.add(difficulty);
//
//            // 插入数据库（使用单词ID而非循环计数器）
//            if(word.equals("low")){
//                log.info(word);
//            }
//
//            difficultyMapper.updateDifficulty(word, difficulty);
//
//    }
//
//        return difficulties;
//    }
//
//    @Override
//    public List<String> getWords() {
//        return difficultyMapper.getWords();
//    }
//
//    // 计算基础结构难度
//    private double calculateBaseDifficulty(String word) {
//        int length = word.length();
//
//        // 1. 长度权重（越长越难，非线性增长）
//        double lengthWeight = Math.min(4.0, Math.pow(length, 1.2) * 0.1);
//
//        // 2. 音节数权重
//        int syllables = countSyllables(word);
//        double syllableWeight = Math.min(2.0, syllables * 0.3);
//
//        // 3. 字符熵（衡量字符分布复杂度）
//        double entropy = calculateEntropy(word);
//        double entropyWeight = Math.min(2.0, entropy * 0.5);
//
//        return lengthWeight + syllableWeight + entropyWeight;
//    }
//
//    // 计算拼写复杂度
//    private double calculateSpellingComplexity(String word) {
//        word = word.toLowerCase();
//
//        // 1. 元音辅音比例
//        double vowelRatio = countMatches(word, VOWEL_PATTERN) / (double) word.length();
//        double consonantRatio = countMatches(word, CONSONANT_PATTERN) / (double) word.length();
//        double ratioComplexity = Math.abs(vowelRatio - consonantRatio) * 2.0;
//
//        // 2. 重复字符比例
//        double repeatedRatio = countRepeatedCharacters(word) / (double) word.length();
//        double repeatComplexity = Math.min(1.5, repeatedRatio * 5.0);
//
//        // 3. 连续辅音难度
//        double consecutiveConsonants = countConsecutiveConsonants(word);
//        double consonantComplexity = Math.min(1.0, consecutiveConsonants * 0.2);
//
//        // 4. 罕见字母组合
//        double rareComboScore = Math.min(1.0, scoreRareLetterCombinations(word));
//
//        // 限制总拼写复杂度
//        return Math.min(4.0, ratioComplexity + repeatComplexity + consonantComplexity + rareComboScore);
//    }
//
//    // 计算词频权重
//    private double calculateFrequencyWeight(String word) {
//        // 获取词频，默认值为1
//        Integer frequency = difficultyMapper.getFrequency(word);
//        if (frequency == null) {
//            frequency = 1;
//        }
//
//        // 词频范围参数
//        double minFreq = 1.0;        // 最小词频
//        double maxFreq = 200000.0;  // 最大词频
//
//        // 归一化词频到0-1范围（使用对数缩放增强低频敏感度）
//        double normalizedFreq = Math.log(frequency / minFreq + 1) /
//                Math.log(maxFreq / minFreq + 1);
//
//        // 非线性转换：Sigmoid函数平滑过渡，高频区域快速衰减
//        double sigmoid = 1.0 / (1.0 + Math.exp(-6 * (normalizedFreq - 0.5)));
//
//        // 映射到0-4分范围，反转（高频词权重低）
//        double weight = 4.0 * (1.0 - sigmoid);
//
//        // 确保结果在有效范围内（冗余保护）
//        return Math.max(0.0, Math.min(4.0, weight));
//    }
//
//    // 统计音节数（简化算法）
//    private int countSyllables(String word) {
//        word = word.toLowerCase();
//        int count = 0;
//
//        // 元音序列
//        String[] vowels = {"a", "e", "i", "o", "u", "y"};
//
//        // 检查单词是否以不发音的-e结尾
//        boolean endsWithSilentE = word.endsWith("e") &&
//                !word.endsWith("le") &&
//                !word.endsWith("ee") &&
//                !word.endsWith("ye") &&
//                !word.endsWith("oe");
//
//        // 计算元音序列数
//        boolean prevWasVowel = false;
//        for (char c : word.toCharArray()) {
//            boolean isVowel = false;
//            for (String v : vowels) {
//                if (c == v.charAt(0)) {
//                    isVowel = true;
//                    break;
//                }
//            }
//
//            if (isVowel && !prevWasVowel) {
//                count++;
//            }
//            prevWasVowel = isVowel;
//        }
//
//        // 调整不发音的-e
//        if (endsWithSilentE && count > 1) {
//            count--;
//        }
//
//        // 确保至少有一个音节
//        return Math.max(1, count);
//    }
//
//    // 计算字符熵（字符分布复杂度）
//    private double calculateEntropy(String word) {
//        Map<Character, Integer> charCounts = new HashMap<>();
//        for (char c : word.toLowerCase().toCharArray()) {
//            charCounts.put(c, charCounts.getOrDefault(c, 0) + 1);
//        }
//
//        double entropy = 0.0;
//        int length = word.length();
//
//        for (int count : charCounts.values()) {
//            double p = (double) count / length;
//            entropy -= p * Math.log(p) / Math.log(2); // 以2为底的对数
//        }
//
//        return entropy;
//    }
//
//    // 统计匹配正则的字符数
//    private int countMatches(String word, Pattern pattern) {
//        Matcher matcher = pattern.matcher(word);
//        int count = 0;
//        while (matcher.find()) {
//            count++;
//        }
//        return count;
//    }
//
//    // 统计重复字符数
//    private int countRepeatedCharacters(String word) {
//        Set<Character> uniqueChars = new HashSet<>();
//        Set<Character> repeatedChars = new HashSet<>();
//
//        for (char c : word.toCharArray()) {
//            if (!uniqueChars.add(c)) {
//                repeatedChars.add(c);
//            }
//        }
//
//        int count = 0;
//        for (char c : repeatedChars) {
//            count += word.length() - word.replace(String.valueOf(c), "").length() - 1;
//        }
//
//        return count;
//    }
//
//    // 统计连续辅音数
//    private int countConsecutiveConsonants(String word) {
//        int maxConsecutive = 0;
//        int currentConsecutive = 0;
//
//        for (char c : word.toCharArray()) {
//            if (CONSONANT_PATTERN.matcher(String.valueOf(c)).matches()) {
//                currentConsecutive++;
//                maxConsecutive = Math.max(maxConsecutive, currentConsecutive);
//            } else {
//                currentConsecutive = 0;
//            }
//        }
//
//        return maxConsecutive;
//    }
//
//    // 评分罕见字母组合
//    private double scoreRareLetterCombinations(String word) {
//        double score = 0.0;
//
//        // 检查常见双字母组合
//        if (word.contains("ch") || word.contains("sh") || word.contains("th")) {
//            score += 0.1;
//        }
//
//        // 检查罕见双字母组合
//        if (word.contains("zh") || word.contains("ph") || word.contains("gh")) {
//            score += 0.3;
//        }
//
//        // 检查三字母组合
//        if (word.contains("tch") || word.contains("sch") || word.contains("str")) {
//            score += 0.2;
//        }
//
//        // 检查罕见字符
//        if (word.contains("x") || word.contains("q") || word.contains("z")) {
//            score += 0.2;
//        }
//
//        return score;
//    }

}
